// pages/important-alerts/alerts.js
import http from '../../utils/request';

Page({
    data: {
        selectedDate: null, // 日期时间戳
        selectedTime: '09:00', // 默认时间设为上午9点
        keyboardHeight: 0, // 当前键盘高度
        formattedDate: '',
        alertContent: '',
        employeeNumber: '', // 从缓存动态获取
        canSubmit: false,
        deviceInfo: '', // 设备信息
        charCount: 0 // 字符计数器
    },

    // ====================== 输入处理 ======================
    handleInputFocus() {
        console.log('[TRACE] 输入框聚焦');
        // iOS设备特殊处理
        const systemInfo = wx.getSystemInfoSync();
        if (systemInfo.platform === 'ios') {
            this.iosScrollHandler();
        }
    },

    handleInputBlur() {
        console.log('[TRACE] 输入框失焦');
        this.setData({
            keyboardHeight: 0
        });
    },

    // ====================== iOS特殊处理 ======================
    iosScrollHandler() {
        console.log('[TRACE] 执行iOS滚动处理');
        setTimeout(() => {
            const query = wx.createSelectorQuery();
            query.select('.input-container').boundingClientRect(rect => {
                const windowInfo = wx.getWindowInfo();
                console.log(`[DEBUG] 输入框底部位置: ${rect.bottom} 窗口高度: ${windowInfo.windowHeight}`);

                if (rect.bottom > windowInfo.windowHeight * 0.75) {
                    wx.pageScrollTo({
                        scrollTop: windowInfo.windowHeight * 2,
                        duration: 280,
                        success: () => console.log('[SUCCESS] iOS滚动完成'),
                        fail: (err) => console.error('[ERROR] iOS滚动失败:', err)
                    });
                }
            }).exec();
        }, 380);
    },

    // ====================== 日期选择处理 ======================
    handleDateSelect(event) {
        console.log('[DEBUG] 原始日期数据:', event.detail);
        try {
            const dateObj = new Date(event.detail);
            if (isNaN(dateObj)) {
                throw new Error('无效日期值');
            }

            const timestamp = dateObj.getTime();
            console.log('[DEBUG] 转换后时间戳:', timestamp);

            this.setData({
                selectedDate: timestamp,
                formattedDate: this.formatDate(dateObj)
            }, () => {
                console.log('[TRACE] 日期更新完成', this.data.formattedDate);
            });

        } catch (err) {
            console.error('[ERROR] 日期处理失败:', err);
            wx.showToast({
                title: '日期选择无效',
                icon: 'none',
                duration: 2000
            });
        }
    },

    handleTimeChange(e) {
        console.log('[DEBUG] 时间选择变更:', e.detail.value);
        this.setData({
            selectedTime: e.detail.value
        }, () => {
            this.generateFinalDateTime();
        });
    },

    // ====================== 日期时间处理 ======================
    generateFinalDateTime() {
        const {
            selectedDate,
            selectedTime
        } = this.data;
        if (!selectedDate || !selectedTime) {
            console.log('[WARN] 生成日期缺少必要参数');
            return;
        }

        try {
            const baseDate = new Date(selectedDate);
            const [hours, minutes] = selectedTime.split(':').map(Number);

            // 创建最终日期对象（本地时区）
            const finalDate = new Date(
                baseDate.getFullYear(),
                baseDate.getMonth(),
                baseDate.getDate(),
                hours,
                minutes
            );

            console.log('[DEBUG] 生成最终日期:', {
                local: finalDate.toLocaleString(),
                iso: finalDate.toISOString(),
                timestamp: finalDate.getTime()
            });

            this.setData({
                formattedDate: this.formatDateTime(finalDate)
            });

        } catch (err) {
            console.error('[ERROR] 日期生成失败:', err);
            wx.showToast({
                title: '时间设置错误',
                icon: 'none',
                duration: 2000
            });
        }
    },

    // ====================== 工具方法 ======================
    formatDateTime(date) {
        const pad = n => n.toString().padStart(2, '0');
        return `${date.getFullYear()}-${pad(date.getMonth()+1)}-${pad(date.getDate())} ` +
            `${pad(date.getHours())}:${pad(date.getMinutes())}:00`;
    },

    formatDate(date) {
        const pad = n => n.toString().padStart(2, '0');
        return `${date.getFullYear()}-${pad(date.getMonth()+1)}-${pad(date.getDate())}`;
    },

    // ====================== 生命周期 ======================
    onLoad() {
        console.log('[TRACE] 页面初始化');
        wx.onKeyboardHeightChange(res => {
            console.log(`[TRACE] 键盘高度变化: ${res.height}px`);
            this.setData({
                keyboardHeight: res.height
            });
        });

        this.initUserInfo();
    },

    onShow() {
        console.log('[TRACE] 页面显示');
        this.checkLoginStatus();
        this.checkSubmitStatus();
    },

    // ====================== 登录状态检查 ======================  
    checkLoginStatus() {
      try {
        const userInfo = wx.getStorageSync('userInfo');
        
        // 新增用户名读取逻辑
        const userName = userInfo.name || '未知用户'; // 添加默认值

        if (!userInfo?.employee_number) {
          this.showLoginAlert();
          return;
        }
        
        this.setData(
          { employeeNumber: userInfo.employee_number.trim(),
            userName: userName // 新增用户名存储
          },
        );
        
      } catch (error) {
        console.error('存储读取失败:', error);
        this.showLoginAlert();
      }
    },
  
    showLoginAlert() {
        wx.showModal({
          title: '未登录',
          content: '请先登录后再使用该功能',
          confirmText: '去登录',
          cancelText: '返回首页', // 明确提示取消操作的含义
          success: (res) => {
            if (res.confirm) {
              wx.reLaunch({ url: '/pages/user/user' });
            } else if (res.cancel) {
              // 增加页面堆栈判断防止报错
              if (getCurrentPages().length > 1) {
                wx.navigateBack({ delta: 1 }); // 返回上一页
              } else {
                wx.reLaunch({ url: '/pages/home/home' }); // 无上一页时回首页
              }
            }
          },
          fail: (err) => {
            console.error('弹窗调用失败:', err);
          }
        });
      },

    // ====================== 用户信息 ======================
    initUserInfo() {
        console.log('[TRACE] 初始化用户信息');
        try {
            const userInfo = wx.getStorageSync('userInfo');
            if (!userInfo?.employee_number) {
                console.log('[WARN] 未找到用户信息，跳转登录');
                wx.redirectTo({
                    url: '/pages/login/login'
                });
                return;
            }

            this.setData({
                employeeNumber: userInfo.employee_number,
                deviceInfo: `${wx.getSystemInfoSync().model} ${wx.getSystemInfoSync().system}`
            }, () => {
                console.log('[TRACE] 用户信息更新完成');
            });

        } catch (err) {
            console.error('[ERROR] 用户信息初始化失败:', err);
        }
    },

    // ====================== 表单验证 ======================
    onContentInput(e) {
        const rawValue = e.detail.value;
        console.log('[TRACE] 输入内容:', rawValue);

        // 清理和标准化输入
        const cleanValue = rawValue
            .replace(/[\uD800-\uDFFF]/g, '') // 过滤无效Unicode
            .replace(/\s+/g, ' ') // 合并连续空格
            .slice(0, 200);

        // 精确计算字符数（支持Unicode）
        const currentLength = [...cleanValue].length;

        this.setData({
            alertContent: cleanValue,
            charCount: currentLength
        }, () => {
            this.checkSubmitStatus();
        });
    },

    checkSubmitStatus() {
        const {
            selectedDate,
            alertContent
        } = this.data;

        // 日期有效性验证（允许历史日期）
        const isDateValid = !!selectedDate && !isNaN(selectedDate);

        // 内容验证（去空格后非空且总长度合规）
        const isContentValid = alertContent.trim().length > 0 && [...alertContent].length <= 200;

        console.log('[VALID] 验证结果:', {
            dateValid: isDateValid,
            contentValid: isContentValid,
            date: selectedDate,
            contentLength: [...alertContent].length
        });

        this.setData({
            canSubmit: isDateValid && isContentValid
        });

        return this.data.canSubmit;
    },

    // ====================== 提交处理 ======================
    async createReminder() {
        console.log('[TRACE] 尝试提交数据');

        // 双重验证保障
        if (!this.checkSubmitStatus()) {
            console.log('[WARN] 提交前验证失败');
            wx.showToast({
                title: '请检查：\n1.已选日期\n2.有效内容（1-200字）',
                icon: 'none',
                duration: 3000
            });
            return;
        }

        if (!wx.addPhoneCalendar) {
            wx.showToast({
                title: '当前微信版本过低',
                icon: 'none'
            });
            return;
        }

        const params = {
            employee_number: this.data.employeeNumber,
            alert_content: this.data.alertContent.trim(),
            reminder_date: this.data.formattedDate,
            device_info: this.data.deviceInfo
        };

        try {
            console.log('[DEBUG] 提交参数:', params);
            const res = await http.post('/create_alert', params, {
                needLoading: true,
                timeout: 8000
            });

            if (res?.status === 'success') {
                const calendarResult = await this.handleCalendarSync(params);
                if (calendarResult) {
                    this.resetForm();
                    wx.showToast({
                        title: '提醒创建成功'
                    });
                }
            }
        } catch (err) {
            // 日历错误已在 handleCalendarSync 处理
            if (!err.message.includes('用户取消')) {
                console.error('[ERROR] 提交失败:', err);
                this.handleRequestError(err);
            }
        }
    },

    // ====================== 日历同步 ======================

    // 修改 handleCalendarSync 错误处理
    async handleCalendarSync(params) {
        try {
            console.log('[DEBUG] 开始日历同步流程');
            const startTime = Math.floor(this.data.selectedDate / 1000) +
                this.parseTimeToSeconds(this.data.selectedTime);

            await this.addToSystemCalendar(startTime, params);
            console.log('[DEBUG] 日历同步成功');
            return true; // 添加成功标识
        } catch (err) {
            console.error('[ERROR] 日历同步失败:', err);
            wx.showToast({
                title: err.message || '添加到日历失败', // 显示具体错误信息
                icon: 'none',
                duration: 3000
            });
            throw err; // 继续抛出错误
        }
    },

    addToSystemCalendar(startTime, params) {
        return new Promise((resolve, reject) => {
            wx.addPhoneCalendar({
                title: '重要提醒',
                startTime: startTime,
                endTime: startTime + 3600,
                description: params.alert_content,
                success: (res) => {
                    console.log('[SUCCESS] 日历添加成功:', res);
                    resolve(res);
                },
                fail: (err) => {
                    console.error('[ERROR] 日历添加失败:', err);
                    // 识别用户取消操作
                    const errorMsg = err.errMsg.includes('cancel') ?
                        '用户取消添加' :
                        this.mapCalendarError(err.errCode);
                    reject({
                        code: err.errCode,
                        message: errorMsg
                    });
                }
            });
        });
    },

    parseTimeToSeconds(timeString) {
        const [hours, minutes] = timeString.split(':').map(Number);
        return hours * 3600 + minutes * 60;
    },

    // ====================== 错误处理 ======================
    handleRequestError(err) {
        console.error('[ERROR] 完整错误信息:', err);
        const errorMap = {
            400: '请求参数错误',
            401: '请重新登录',
            500: '服务器繁忙',
            ECONNABORTED: '请求超时',
            10003: '需要日历权限',
            10004: '设备不支持日历'
        };
        wx.showToast({
            title: errorMap[err.code] || err.message || '操作失败',
            icon: 'none',
            duration: 3000
        });
    },

    // 更新日历错误映射
    mapCalendarError(code) {
        return {
            10003: '用户取消添加', // 根据实际错误码调整
            10004: '当前设备不支持',
            10005: '日历事件冲突'
        } [code] || '操作失败，请重试';
    },

    // ====================== 表单重置 ======================
    resetForm() {
        console.log('[TRACE] 重置表单');
        this.setData({
            selectedDate: null,
            selectedTime: '09:00',
            formattedDate: '',
            alertContent: '',
            canSubmit: false,
            charCount: 0
        });
    }
});